var Colin = {};
Colin.Methods = {};
//去除空格  type 1-所有空格  2-前后空格  3-前空格 4-后空格
//ecDo.trim('  1235asd',1)
//result：1235asd
//这个方法有原生的方案代替，但是考虑到有时候开发PC站需要兼容IE8，所以就还是继续保留
Colin.Methods.trim = function (str, type) {
    switch (type) {
        case 1:
            return str.replace(/\s+/g, "");
        case 2:
            return str.replace(/(^\s*)|(\s*$)/g, "");
        case 3:
            return str.replace(/(^\s*)/g, "");
        case 4:
            return str.replace(/(\s*$)/g, "");
        default:
            return str;
    }
};

//字母大小写切换
Colin.Methods.changeCase = function (str, type) {
    //字母大小写切换
    /*type
     1:首字母大写
     2：首页母小写
     3：大小写转换
     4：全部大写
     5：全部小写
     * */
    function ToggleCase(str) {
        var itemText = ""
        str.split("").forEach(
            function (item) {
                if (/^([a-z]+)/.test(item)) {
                    itemText += item.toUpperCase();
                } else if (/^([A-Z]+)/.test(item)) {
                    itemText += item.toLowerCase();
                } else {
                    itemText += item;
                }
            });
        return itemText;
    }

    switch (type) {
        case 1:
            return str.replace(/\b\w+\b/g, function (word) {
                return word.substring(0, 1).toUpperCase() + word.substring(1).toLowerCase();
            });
        case 2:
            return str.replace(/\b\w+\b/g, function (word) {
                return word.substring(0, 1).toLowerCase() + word.substring(1).toUpperCase();
            });
        case 3:
            return ToggleCase(str);
        case 4:
            return str.toUpperCase();
        case 5:
            return str.toLowerCase();
        default:
            return str;
    }


};
//字符串替换
Colin.Methods.replaceAll = function (str, AFindText, ARepText) {
    raRegExp = new RegExp(AFindText, "g");
    return str.replace(raRegExp, ARepText);
};
//数组去重
Colin.Methods.removeRepeatArray = function (arr) {
    return arr.filter(function (item, index, self) {
        return self.indexOf(item) === index;
    });
};
//数组顺序打乱
Colin.Methods.upsetArr = function (arr) {
    return arr.sort(function () {
        return Math.random() - 0.5
    });
};
//3数组最大值
Colin.Methods.maxArr = function (arr) {
    return Math.max.apply(null, arr);
};

//数组最小值
Colin.Methods.minArr = function (arr) {
    return Math.min.apply(null, arr);
};

//从数组中随机获取元素
Colin.Methods.randomOne = function (arr) {
    return arr[Math.floor(Math.random() * arr.length)];
};

//返回数组（字符串）一个元素出现的次数
Colin.Methods.getEleCount = function (ele) {
    var num = 0;
    for (var i = 0, len = obj.length; i < len; i++) {
        if (ele === obj[i]) {
            num++;
        }
    }
    return num;
};


//检测对象是否有哪个类名
Colin.Methods.hasClass = function (obj, classStr) {
    if (obj.className && this.trim(obj.className, 1) !== "") {
        var arr = obj.className.split(/\s+/); //这个正则表达式是因为class可以有多个,判断是否包含
        return (arr.indexOf(classStr) == -1) ? false : true;
    } else {
        return false;
    }
};

//现金额大写转换函数
Colin.Methods.upDigit = function (n) {
    var fraction = ['角', '分', '厘'];
    var digit = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'];
    var unit = [
        ['元', '万', '亿'],
        ['', '拾', '佰', '仟']
    ];
    var head = n < 0 ? '欠人民币' : '人民币';
    n = Math.abs(n);
    var s = '';
    for (var i = 0; i < fraction.length; i++) {
        s += (digit[Math.floor(n * 10 * Math.pow(10, i)) % 10] + fraction[i]).replace(/零./, '');
    }
    s = s || '整';
    n = Math.floor(n);
    for (var i = 0; i < unit[0].length && n > 0; i++) {
        var p = '';
        for (var j = 0; j < unit[1].length && n > 0; j++) {
            p = digit[n % 10] + unit[1][j] + p;
            n = Math.floor(n / 10);
        }
        s = p.replace(/(零.)*零$/, '').replace(/^$/, '零') + unit[0][i] + s;
        //s = p + unit[0][i] + s;
    }
    return head + s.replace(/(零.)*零元/, '元').replace(/(零.)+/g, '零').replace(/^整$/, '零元整');


};


//获取url参数
Colin.Methods.getUrlPrmt = function (url) {
    url = url ? url : window.location.href;
    var _pa = url.substring(url.indexOf('?') + 1),
        _arrS = _pa.split('&'),
        _rs = {};
    for (var i = 0, _len = _arrS.length; i < _len; i++) {
        var pos = _arrS[i].indexOf('=');
        if (pos == -1) {
            continue;
        }
        var name = _arrS[i].substring(0, pos),
            value = window.decodeURIComponent(_arrS[i].substring(pos + 1));
        _rs[name] = value;
    }
    return _rs;
};

//随机返回一个范围的数字
Colin.Methods.randomNumber = function (n1, n2) {
    if (arguments.length === 2) {
        return Math.round(n1 + Math.random() * (n2 - n1));
    }
    else if (arguments.length === 1) {
        return Math.round(Math.random() * n1)
    }
    else {
        return Math.round(Math.random() * 255)
    }
};


//随机产生颜色
Colin.Methods.randomColor = function () {
    return '#' + Math.random().toString(16).substring(2).substr(0, 6);
};


//封装ajax
Colin.Methods.ajax = function (obj) {
    obj = obj || {};
    obj.type = obj.type.toUpperCase() || 'POST';
    obj.url = obj.url || '';
    obj.async = obj.async || true;
    obj.data = obj.data || null;
    obj.success = obj.success || function () {
    };
    obj.error = obj.error || function () {
    };
    var xmlHttp = null;
    if (XMLHttpRequest) {
        xmlHttp = new XMLHttpRequest();
    } else {
        xmlHttp = new ActiveXObject('Microsoft.XMLHTTP');
    }
    var params = [];
    for (var key in obj.data) {
        params.push(key + '=' + obj.data[key]);
    }
    var postData = params.join('&');
    if (obj.type.toUpperCase() === 'POST') {
        xmlHttp.open(obj.type, obj.url, obj.async);
        xmlHttp.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded;charset=utf-8');
        xmlHttp.send(postData);
    } else if (obj.type.toUpperCase() === 'GET') {
        xmlHttp.open(obj.type, obj.url + '?' + postData, obj.async);
        xmlHttp.send(null);
    }
    xmlHttp.onreadystatechange = function () {
        if (xmlHttp.readyState == 4 && xmlHttp.status == 200) {
            obj.success(xmlHttp.responseText);
        } else {
            obj.error(xmlHttp.responseText);
        }
    };


};


//关键词加标签
Colin.Methods.createKeyExp = function (strArr) {
    var str = "";
    for (var i = 0; i < strArr.length; i++) {
        if (i != strArr.length - 1) {
            str = str + strArr[i] + "|";
        } else {
            str = str + strArr[i];
        }
    }
    return "(" + str + ")";

};
Colin.Methods.findKey = function (str, key, el) {
    var arr = null,
        regStr = null,
        content = null,
        Reg = null,
        _el = el || 'span';
    arr = key.split(/\s+/);
    //alert(regStr); //    如：(前端|过来)
    regStr = this.createKeyExp(arr);
    content = str;
    //alert(Reg);//        /如：(前端|过来)/g
    Reg = new RegExp(regStr, "g");
    //过滤html标签 替换标签，往关键字前后加上标签
    content = content.replace(/<\/?[^>]*>/g, '');
    return content.replace(Reg, "<" + _el + ">$1</" + _el + ">");
};


//数据类型判断
Colin.Methods.istype = function (o, type) {
    if (type) {
        var _type = type.toLowerCase();
    }
    switch (_type) {
        case 'string':
            return Object.prototype.toString.call(o) === '[object String]';
        case 'number':
            return Object.prototype.toString.call(o) === '[object Number]';
        case 'boolean':
            return Object.prototype.toString.call(o) === '[object Boolean]';
        case 'undefined':
            return Object.prototype.toString.call(o) === '[object Undefined]';
        case 'null':
            return Object.prototype.toString.call(o) === '[object Null]';
        case 'function':
            return Object.prototype.toString.call(o) === '[object Function]';
        case 'array':
            return Object.prototype.toString.call(o) === '[object Array]';
        case 'object':
            return Object.prototype.toString.call(o) === '[object Object]';
        case 'nan':
            return isNaN(o);
        case 'elements':
            return Object.prototype.toString.call(o).indexOf('HTML') !== -1
        default:
            return Object.prototype.toString.call(o)
    }


};

/**
 *
 * @desc 判断两个数组是否相等
 * @param {Array} arr1
 * @param {Array} arr2
 * @return {Boolean}
 */
Colin.Methods.arrayEqual = function (arr1, arr2) {
    if (arr1 === arr2) return true;
    if (arr1.length != arr2.length) return false;
    for (var i = 0; i < arr1.length; ++i) {
        if (arr1[i] !== arr2[i]) return false;
    }
    return true;
};


/**
 *
 * @desc  获取一个元素的距离文档(document)的位置，类似jQ中的offset()
 * @param {HTMLElement} ele
 * @returns { {left: number, top: number} }
 */

Colin.Methods.offset = function (ele) {
    var pos = {
        left: 0,
        top: 0
    };
    while (ele) {
        pos.left += ele.offsetLeft;
        pos.top += ele.offsetTop;
        ele = ele.offsetParent;
    }
    ;
    return pos;
};
//封装手机号中间显示星号方法
Colin.Methods.phone = function (phone) {
    var d = /^1[3|4|5|8][0-9]\d{4,8}$/;
    if (!d.test(phone)) {
        alert('请输入手机号码');
        return;
    }
    return phone.substr(0, 3) + '****' + phone.substr(7);
};


//手机rem布局
Colin.Methods.rem = function (maxWidth, designWidth, ratio) {//最大宽,设计稿宽度,倍率
    var designWidth = designWidth || 1080; // 设计稿默认宽度
    var ratio = ratio || 100;
    var docEle = document.documentElement; // 获取html元素
    var htmlDesignWidth = docEle.getAttribute("design-width"); // 得到html标签设置的设计稿宽度
    htmlDesignWidth && (designWidth = htmlDesignWidth); // 设置设计稿宽度
    var changeEvent = function () {
        var w = docEle.clientWidth;
        if (maxWidth) {
            w = Math.min(docEle.clientWidth, maxWidth)
        }
        docEle.clientWidth && (docEle.style.fontSize = ratio * w / designWidth + "px"); // 设置html的fontSize，随着event的改变而改变。
    };
    this.triggerEvent = function (width, max) {
        designWidth = width || designWidth;
        maxWidth = max;
        changeEvent();
    }
    changeEvent();
    window.addEventListener("resize", changeEvent, false); // 添加缩放事件
    window.addEventListener("onorientationchange", changeEvent, false); // 添加document载入完成的时的事件
};
/**
 *
 方法说明 关键字高亮
 *
 @method HuoBan.Methods.replaceSearchKey
 *
 @for HuoBan.Methods
 *
 @param {String} keyword 关键字
 @param {String} tempHTML 需要替换的关键字模版
 @param {String} color 高亮的颜色
 @param {Boolean} bold 是否需要加粗显示
 *
 @return {String} 返回值说明 格式化之后的Html
 *
 @example
 Colin.Methods.replaceSearchKey('Hello', "Hello World", 'red', true)
 */

Colin.Methods.replaceSearchKey = function (keyword, tempHTML, color, bold) {
    if (keyword == "")
        return;
    var htmlReg = new RegExp("\<.*?\>", "i");
    var arrA = new Array();
    for (var i = 0; true; i++) {
        var m = htmlReg.exec(tempHTML);
        if (m) {
            arrA[i] = m;
        } else {
            break;
        }
        tempHTML = tempHTML.replace(m, "[[[[" + i + "]]]]");
    }
    var replaceText;
    if (bold)
        replaceText = "<b style='color:" + color + ";'>$1</b>";
    else
        replaceText = "<font style='color:" + color + ";'>$1</font>";
    var arrayWord = keyword.split(',');
    for (var w = 0; w < arrayWord.length; w++) {
        var r = new RegExp("(" + arrayWord[w].replace(/[(){}.+*?^$|\\\[\]]/g, "\\$&") + ")", "ig");
        tempHTML = tempHTML.replace(r, replaceText);
    }
    for (var i = 0; i < arrA.length; i++) {
        tempHTML = tempHTML.replace("[[[[" + i + "]]]]", arrA[i]);
    }
    // $("#" + id).html(tempHTML);
    return tempHTML;
};
//将金额数字每三位一逗号分隔
Colin.Methods.formatNumber = function (n) {
    var b = parseInt(n).toString();
    var len = b.length;
    if (len <= 3) {
        return b;
    }
    var r = len % 3;
    return r > 0 ? b.slice(0, r) + "," + b.slice(r, len).match(/\d{3}/g).join(",") : b.slice(r, len).match(/\d{3}/g).join(",");
};
//利用递归来实现深拷贝，如果对象属性的值是引用类型（Array,Object），
// 那么对该属性进行深拷贝，直到遍历到属性的值是基本类型为止。
Colin.Methods.deepClone = function (obj) {

    if (!obj && typeof obj !== 'object') {
        return;
    }
    var newObj = obj.constructor === Array ? [] : {};
    for (var key in obj) {
        if (obj[key]) {
            if (obj[key] && typeof obj[key] === 'object') {
                newObj[key] = obj[key].constructor === Array ? [] : {};
                //递归
                newObj[key] = deepClone(obj[key]);
            } else {
                newObj[key] = obj[key];
            }
        }
    }
    return newObj;

};


//判断键盘大小写是否开启，必须在用户输入时才能检测出，采用keypress事件检测
/*
  @example:
  $(el).keypress(function (e) {
  var ev=e||window.event;
  Colin.Methods.testCapsLock(ev)
});
*/

Colin.Methods.testCapsLock = function (e) {
    var valueCapsLock = e.keyCode ? e.keyCode : e.which; // 按键
    var valueShift = e.shiftKey ? e.shiftKey : ((valueCapsLock == 16) ? true : false); // shift键是否按住
    if (((valueCapsLock >= 65 && valueCapsLock <= 90) && !valueShift) // 输入了大写字母，并且shift键没有按住，说明Caps Lock打开
        || ((valueCapsLock >= 97 && valueCapsLock <= 122) && valueShift)) {// 输入了小写字母，并且按住 shift键<span style="font-family: Arial, Helvetica, sans-serif;">，说明</span><span style="font-family:SimSun;">Caps Lock</span><span style="font-family: Arial, Helvetica, sans-serif;">打开</span>
        return true;
    } else {
        return false;
    }
};
// 手机号中间显示星号方法
Colin.Methods.phoneStar = function () {
    var d = /^1[3|4|5|8][0-9]\d{4,8}$/;
    if (!d.test(phone)) {
        alert('请输入手机号码');
        return;
    }
    return phone.substr(0, 3) + '****' + phone.substr(7);

};

//实现图片上传服务器
function ajaxFileUpload(target, callback) {
    var prefix = $(target).val().substring($(target).val().lastIndexOf(".") + 1, $(target).val().length);
    var pid = $(target).attr("id");
    if (prefix != 'png' && prefix != 'jpg' && prefix != 'jpeg') {
        //alert("只能上传jpg，png，jpeg");
        return;
    }
    $.ajaxFileUpload({
        url: '/huoban-sales/http/sales/user/image/api_ie/upload.do', //用于文件上传的服务器端请求地址
        secureuri: false, //一般设置为false
        fileElementId: pid, //文件上传空间的id属性  <input type="file" id="file" name="file" />
        type: 'post',
        dataType: 'json', //返回值类型 一般设置为json
        success: function (data) //服务器成功响应处理函数
        {
            console.log(data.data);
            callback(data.data, pid);

        },
        error: function (data) //服务器响应失败处理函数
        {
            alert("上传失败");
        }
    });
    return false;
}

//
// 窗口的resize、scroll、输入框内容校验等操作时，如果这些操作处理函数是较为复杂或页面频繁重渲染等操作时，
// 在这种情况下如果事件触发的频率无限制，会加重浏览器的负担，导致用户体验非常糟糕。此时我们可以采用debounce
// （防抖）和throttle（节流）的方式来减少触发的频率，同时又不影响实际效果。

/**
 * @desc 函数防抖
 * @param func 函数
 * @param wait 延迟执行毫秒数
 * @param immediate true 表立即执行，false 表非立即执行
 */
function debounce(func, wait, immediate) {
    var timeout;

    return function () {
        var context = this;
        var args = arguments;

        if (timeout) clearTimeout(timeout);
        if (immediate) {
            var callNow = !timeout;
            timeout = setTimeout(function () {
                timeout = null;
            }, wait)
            if (callNow) func.apply(context, args)
        }
        else {
            timeout = setTimeout(function () {
                func.apply(context, args)
            }, wait);
        }
    }
}

/**
 * @desc 函数节流
 * @param func 函数
 * @param wait 延迟执行毫秒数
 * @param type 1 表时间戳版，2 表定时器版
 */
function throttle(func, wait, type) {
    if (type === 1) {
        var previous = 0;
    } else if (type === 2) {
        var timeout;
    }

    return function () {
        var context = this;
        var args = arguments;
        if (type === 1) {
            var now = Date.now();

            if (now - previous > wait) {
                func.apply(context, args);
                previous = now;
            }
        } else if (type === 2) {
            if (!timeout) {
                timeout = setTimeout(function () {
                    timeout = null;
                    func.apply(context, args)
                }, wait)
            }
        }

    }
}


//图片压缩
// var obj={
//     width: 160,
//     height: 117,
//     quality: 1
// };


function zipImg(url,obj) {
    var img = new Image();
    img.src = url;
    img.onload = function () {
        var that = this;
        // 默认按比例压缩
        var w = that.width,
            h = that.height,
            scale = w / h;
        w = obj.width || w;
        h = obj.height || (w / scale);
        var quality = 0.7;  // 默认图片质量为0.7
        //生成canvas
        var canvas = document.createElement('canvas');
        var ctx = canvas.getContext('2d');
        // 创建属性节点
        var anw = document.createAttribute("width");
        anw.nodeValue = w;
        var anh = document.createAttribute("height");
        anh.nodeValue = h;
        canvas.setAttributeNode(anw);
        canvas.setAttributeNode(anh);
        ctx.drawImage(that, 0, 0, w, h);
        // 图像质量
        if (obj.quality && obj.quality <= 1 && obj.quality > 0) {
            quality = obj.quality;
        }
        // quality值越小，所绘制出的图像越模糊
        var base64 = canvas.toDataURL('image/jpeg', quality);
        console.log(base64);
    }
}










